﻿#define _CRT_SECURE_NO_WARNINGS 1

//#include <stdio.h>
//#include <stdlib.h>

//#define MAX_SIZE 100
//
//// 定义二元关系的结构体
//typedef struct {
//    int a;
//    int b;
//} Relation;
//
//// 检查是否自反
//int isReflexive(Relation relations[], int size, int elements[]) {
//    for (int i = 0; i < size; i++) {
//        if (!elements[i * size + i]) {
//            return 0;
//        }
//    }
//    return 1;
//}
//
//// 检查是否对称
//int isSymmetric(Relation relations[], int size, int elements[]) {
//    for (int i = 0; i < size; i++) {
//        for (int j = 0; j < size; j++) {
//            if (elements[i * size + j] && !elements[j * size + i]) {
//                return 0;
//            }
//        }
//    }
//    return 1;
//}
//
//// 检查是否传递
//int isTransitive(Relation relations[], int size, int elements[]) {
//    for (int i = 0; i < size; i++) {
//        for (int j = 0; j < size; j++) {
//            if (elements[i * size + j] && !elements[j * size + i]) {
//                for (int k = 0; k < size; k++) {
//                    if (elements[j * size + k] && !elements[i * size + k]) {
//                        return 0;
//                    }
//                }
//            }
//        }
//    }
//    return 1;
//}
//
//// 判断是否为等价关系
//int isEquivalence(Relation relations[], int size, int elements[]) {
//    return isReflexive(relations, size, elements) &&
//        isSymmetric(relations, size, elements) &&
//        isTransitive(relations, size, elements);
//}
//
//int main() {
//    int size;
//    printf("请输入集合的大小: ");
//    scanf("%d", &size);
//
//    int elements[MAX_SIZE * MAX_SIZE] = { 0 };
//    printf("请输入二元关系（0表示无关系，1表示有关系）:\n");
//    for (int i = 0; i < size * size; i++) {
//        scanf("%d", &elements[i]);
//    }
//
//    if (isEquivalence(NULL, size, elements)) {
//        printf("给定的二元关系是等价关系。\n");
//    }
//    else {
//        printf("给定的二元关系不是等价关系。\n");
//    }
//
//    return 0;
//}


//int main() {
//    // 定义变量p和q
//    int p, q;
//
//    // 输出真值表标题
//    printf("p q p→q !(p→q) !(p→q)∧q\n");
//
//    // 遍历所有可能的p和q组合
//    for (p = 0; p <= 1; p++) {
//        for (q = 0; q <= 1; q++) {
//            // 输出当前p和q的值
//            printf("%d %d ", p, q);
//
//            // 计算p→q的值（如果p为假或q为真，则p→q为真）
//            int implication = !p || q;
//            int a = !implication;
//
//            // 输出p→q的真值
//            printf("%d", implication);
//            printf("	%d	", a);
//            if (a == 0 || implication == 0)
//                printf("0\n");
//            else
//                printf("1\n");
//        }
//    }
//    printf("根据真值表，为永假式。\n");
//
//    return 0;
//}

#include <stdio.h>
#include <stdlib.h>

// 结构体用于表示有序对（用于笛卡尔积）
typedef struct {
    int first;
    int second;
} Pair;

// 函数声明
void inputSet(int** set, int* size);
void printSet(int* set, int size);
int* setDifference(int* setA, int sizeA, int* setB, int sizeB, int* resultSize);
int* setIntersection(int* setA, int sizeA, int* setB, int sizeB, int* resultSize);
int* setUnion(int* setA, int sizeA, int* setB, int sizeB, int* resultSize);
int* setComplement(int* setA, int sizeA, int* universalSet, int sizeU, int* resultSize);
Pair* cartesianProduct(int* setA, int sizeA, int* setB, int sizeB, int* resultSize);

int main() {
    int* setA, * setB;
    int sizeA, sizeB;
    int choice;

    // 输入集合A
    printf("请输入集合A的元素个数：");
    scanf("%d", &sizeA);
    setA = (int*)malloc(sizeA * sizeof(int));
    inputSet(&setA, &sizeA);

    // 输入集合B
    printf("请输入集合B的元素个数：");
    scanf("%d", &sizeB);
    setB = (int*)malloc(sizeB * sizeof(int));
    inputSet(&setB, &sizeB);

    // 菜单展示运算选项
    printf("请选择要进行的集合运算：\n");
    printf("1. 集合差（A - B）\n");
    printf("2. 集合交（A ∩ B）\n");
    printf("3. 集合并（A ∪ B）\n");
    printf("4. 集合补（假设求A相对于全集U的补集，需先确定全集U）\n");
    printf("5. 笛卡尔积（A × B）\n");
    scanf("%d", &choice);

    switch (choice) {
    case 1: {
        int resultSize;
        int* result = setDifference(setA, sizeA, setB, sizeB, &resultSize);
        printf("集合差（A - B）的结果：");
        printSet(result, resultSize);
        free(result);
        break;
    }
    case 2: {
        int resultSize;
        int* result = setIntersection(setA, sizeA, setB, sizeB, &resultSize);
        printf("集合交（A ∩ B）的结果：");
        printSet(result, resultSize);
        free(result);
        break;
    }
    case 3: {
        int resultSize;
        int* result = setUnion(setA, sizeA, setB, sizeB, &resultSize);
        printf("集合并（A ∪ B）的结果：");
        printSet(result, resultSize);
        free(result);
        break;
    }
    case 4: {
        int* universalSet;
        int sizeU;
        printf("请输入全集U的元素个数：");
        scanf("%d", &sizeU);
        universalSet = (int*)malloc(sizeU * sizeof(int));
        inputSet(&universalSet, &sizeU);

        int resultSize;
        int* result = setComplement(setA, sizeA, universalSet, sizeU, &resultSize);
        printf("集合补（∁_U A）的结果：");
        printSet(result, resultSize);
        free(universalSet);
        free(result);
        break;
    }
    case 5: {
        int resultSize;
        Pair* result = cartesianProduct(setA, sizeA, setB, sizeB, &resultSize);
        printf("笛卡尔积（A × B）的结果：\n");
        for (int i = 0; i < resultSize; i++) {
            printf("(%d, %d) ", result[i].first, result[i].second);
        }
        free(result);
        break;
    }
    default:
        printf("无效的选择，请重新运行程序并选择正确的运算。");
    }

    free(setA);
    free(setB);
    return 0;
}

// 输入集合元素的函数
void inputSet(int** set, int* size) {
    printf("请依次输入集合元素：\n");
    for (int i = 0; i < *size; i++) {
        scanf("%d", &(*set)[i]);
    }
}

// 输出集合的函数
void printSet(int* set, int size) {
    printf("{");
    for (int i = 0; i < size; i++) {
        printf("%d", set[i]);
        if (i < size - 1) {
            printf(", ");
        }
    }
    printf("}\n");
}

// 集合差运算函数
int* setDifference(int* setA, int sizeA, int* setB, int sizeB, int* resultSize) {
    int count = 0;
    int* result = (int*)malloc(sizeA * sizeof(int));
    for (int i = 0; i < sizeA; i++) {
        int flag = 0;
        for (int j = 0; j < sizeB; j++) {
            if (setA[i] == setB[j]) {
                flag = 1;
                break;
            }
        }
        if (flag == 0) {
            result[count++] = setA[i];
        }
    }
    *resultSize = count;
    return result;
}

// 集合交运算函数
int* setIntersection(int* setA, int sizeA, int* setB, int sizeB, int* resultSize) {
    int count = 0;
    int* result = (int*)malloc((sizeA < sizeB ? sizeA : sizeB) * sizeof(int));
    for (int i = 0; i < sizeA; i++) {
        for (int j = 0; j < sizeB; j++) {
            if (setA[i] == setB[j]) {
                result[count++] = setA[i];
                break;
            }
        }
    }
    *resultSize = count;
    return result;
}

// 集合并运算函数
int* setUnion(int* setA, int sizeA, int* setB, int sizeB, int* resultSize) {
    int count = 0;
    int* result = (int*)malloc((sizeA + sizeB) * sizeof(int));
    // 先复制集合A到结果集合
    for (int i = 0; i < sizeA; i++) {
        result[count++] = setA[i];
    }
    // 检查集合B元素是否已在集合A中，不在则添加到结果集合
    for (int i = 0; i < sizeB; i++) {
        int flag = 0;
        for (int j = 0; j < sizeA; j++) {
            if (setB[i] == setA[j]) {
                flag = 1;
                break;
            }
        }
        if (flag == 0) {
            result[count++] = setB[i];
        }
    }
    *resultSize = count;
    return result;
}

// 集合补运算函数
int* setComplement(int* setA, int sizeA, int* universalSet, int sizeU, int* resultSize) {
    int count = 0;
    int* result = (int*)malloc(sizeU * sizeof(int));
    for (int i = 0; i < sizeU; i++) {
        int flag = 0;
        for (int j = 0; j < sizeA; j++) {
            if (universalSet[i] == setA[j]) {
                flag = 1;
                break;
            }
        }
        if (flag == 0) {
            result[count++] = universalSet[i];
        }
    }
    *resultSize = count;
    return result;
}

// 笛卡尔积运算函数
Pair* cartesianProduct(int* setA, int sizeA, int* setB, int sizeB, int* resultSize) {
    int count = 0;
    Pair* result = (Pair*)malloc(sizeA * sizeB * sizeof(Pair));
    for (int i = 0; i < sizeA; i++) {
        for (int j = 0; j < sizeB; j++) {
            result[count].first = setA[i];
            result[count].second = setB[j];
            count++;
        }
    }
    *resultSize = count;
    return result;
}